home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / circuits / spice2g6.z / spice2g6 / spice / matloc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-21  |  24.9 KB  |  754 lines
  1. /* matloc.f -- translated by f2c (version of 3 February 1990  3:36:42).
  2.    You must link the resulting object file with the libraries:
  3.     -lF77 -lI77 -lm -lc   (in that order)
  4. */
  5.  
  6. #include "f2c.h"
  7.  
  8. /* Common Block Declarations */
  9.  
  10. struct {
  11.     integer ielmnt, isbckt, nsbckt, iunsat, nunsat, itemps, numtem, isens, 
  12.         nsens, ifour, nfour, ifield, icode, idelim, icolum, insize, 
  13.         junode, lsbkpt, numbkp, iorder, jmnode, iur, iuc, ilc, ilr, 
  14.         numoff, isr, nmoffc, iseq, iseq1, neqn, nodevs, ndiag, iswap, 
  15.         iequa, macins, lvnim1, lx0, lvn, lynl, lyu, lyl, lx1, lx2, lx3, 
  16.         lx4, lx5, lx6, lx7, ld0, ld1, ltd, imynl, imvn, lcvn, nsnod, 
  17.         nsmat, nsval, icnod, icmat, icval, loutpt, lpol, lzer, irswpf, 
  18.         irswpr, icswpf, icswpr, irpt, jcpt, irowno, jcolno, nttbr, nttar, 
  19.         lvntmp;
  20. } tabinf_;
  21.  
  22. #define tabinf_1 tabinf_
  23.  
  24. struct {
  25.     integer locate[50], jelcnt[50], nunods, ncnods, numnod, nstop, nut, nlt, 
  26.         nxtrm, ndist, ntlin, ibr, numvs, numalt, numcyc;
  27. } cirdat_;
  28.  
  29. #define cirdat_1 cirdat_
  30.  
  31. struct {
  32.     doublereal omega, time, delta, delold[7], ag[7], vt, xni, egfet, xmu, 
  33.         sfactr;
  34.     integer mode, modedc, icalc, initf, method, iord, maxord, noncon, iterno, 
  35.         itemno, nosolv, modac, ipiv, ivmflg, ipostp, iscrch, iofile;
  36. } status_;
  37.  
  38. #define status_1 status_
  39.  
  40. struct {
  41.     doublereal fstart, fstop, fincr, skw2, refprl, spw2;
  42.     integer jacflg, idfreq, inoise, nosprt, nosout, nosin, idist, idprt;
  43. } ac_;
  44.  
  45. #define ac_1 ac_
  46.  
  47. struct {
  48.     doublereal value[200000];
  49. } blank_;
  50.  
  51. #define blank_1 blank_
  52.  
  53. /*<       subroutine matloc >*/
  54. /* Subroutine */ int matloc_()
  55. {
  56.     /* System generated locals */
  57.     integer i_1;
  58.  
  59.     /* Local variables */
  60.     static integer ndim, lnod, lmat, iptr, node1, node2, node3, node4, node5, 
  61.         node6, node7, i;
  62.     extern integer indxx_();
  63.     static integer locvs;
  64. #define nodplc ((integer *)&blank_1)
  65. #define cvalue ((complex *)&blank_1)
  66.     static integer nl1, nl2, locvst, ni1, ni2, loc, kbr, ibr1, ibr2;
  67.  
  68. /*<       implicit double precision (a-h,o-z) >*/
  69.  
  70. /*     this routine stores the locations of the various matrix terms to */
  71.  
  72. /* which the different circuit elements contribute. */
  73.  
  74. /* spice version 2g.6  sccsid=tabinf 3/15/83 */
  75. /*<       common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem, >*/
  76. /*<      1   isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize, >*/
  77. /*<      2   junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr, >*/
  78. /*<      3   nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1, >*/
  79. /*<      4   lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd, >*/
  80. /*<      5   imynl,imvn,lcvn,nsnod,nsmat,nsval,icnod,icmat,icval, >*/
  81. /*<      6   loutpt,lpol,lzer,irswpf,irswpr,icswpf,icswpr,irpt,jcpt, >*/
  82. /*<      7   irowno,jcolno,nttbr,nttar,lvntmp >*/
  83. /* spice version 2g.6  sccsid=cirdat 3/15/83 */
  84. /*<       common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop, >*/
  85. /*<      1   nut,nlt,nxtrm,ndist,ntlin,ibr,numvs,numalt,numcyc >*/
  86. /* spice version 2g.6  sccsid=status 3/15/83 */
  87. /*<       common /status/ omega,time,delta,delold(7),ag(7),vt,xni,egfet, >*/
  88. /*<      1   xmu,sfactr,mode,modedc,icalc,initf,method,iord,maxord,noncon, >*/
  89. /*<      2   iterno,itemno,nosolv,modac,ipiv,ivmflg,ipostp,iscrch,iofile >*/
  90. /* spice version 2g.6  sccsid=ac 3/15/83 */
  91. /*<       common /ac/ fstart,fstop,fincr,skw2,refprl,spw2,jacflg,idfreq, >*/
  92. /*<      1   inoise,nosprt,nosout,nosin,idist,idprt >*/
  93. /* spice version 2g.6  sccsid=blank 3/15/83 */
  94. /*<       common /blank/ value(200000) >*/
  95. /*<       integer nodplc(64) >*/
  96. /*<       complex cvalue(32) >*/
  97. /*<       equivalence (value(1),nodplc(1),cvalue(1)) >*/
  98.  
  99. /*  resistors */
  100.  
  101. /*<       loc=locate(1) >*/
  102.     loc = cirdat_1.locate[0];
  103. /*<   690 if ((loc.eq.0).or.(nodplc(loc+8).ne.0)) go to 700 >*/
  104. L690:
  105.     if (loc == 0 || nodplc[loc + 7] != 0) {
  106.     goto L700;
  107.     }
  108. /*<       node1=nodplc(loc+2) >*/
  109.     node1 = nodplc[loc + 1];
  110. /*<       node2=nodplc(loc+3) >*/
  111.     node2 = nodplc[loc + 2];
  112. /*<       nodplc(loc+4)=indxx(node1,node2) >*/
  113.     nodplc[loc + 3] = indxx_(&node1, &node2);
  114. /*<       nodplc(loc+5)=indxx(node2,node1) >*/
  115.     nodplc[loc + 4] = indxx_(&node2, &node1);
  116. /*<       nodplc(loc+6)=indxx(node1,node1) >*/
  117.     nodplc[loc + 5] = indxx_(&node1, &node1);
  118. /*<       nodplc(loc+7)=indxx(node2,node2) >*/
  119.     nodplc[loc + 6] = indxx_(&node2, &node2);
  120. /*<       loc=nodplc(loc) >*/
  121.     loc = nodplc[loc - 1];
  122. /*<       go to 690 >*/
  123.     goto L690;
  124.  
  125. /*  capacitors */
  126.  
  127. /*<   700 loc=locate(2) >*/
  128. L700:
  129.     loc = cirdat_1.locate[1];
  130. /*<   710 if ((loc.eq.0).or.(nodplc(loc+12).ne.0)) go to 720 >*/
  131. L710:
  132.     if (loc == 0 || nodplc[loc + 11] != 0) {
  133.     goto L720;
  134.     }
  135. /*<       node1=nodplc(loc+2) >*/
  136.     node1 = nodplc[loc + 1];
  137. /*<       node2=nodplc(loc+3) >*/
  138.     node2 = nodplc[loc + 2];
  139. /*<       nodplc(loc+5)=indxx(node1,node2) >*/
  140.     nodplc[loc + 4] = indxx_(&node1, &node2);
  141. /*<       nodplc(loc+6)=indxx(node2,node1) >*/
  142.     nodplc[loc + 5] = indxx_(&node2, &node1);
  143. /*<       nodplc(loc+10)=indxx(node1,node1) >*/
  144.     nodplc[loc + 9] = indxx_(&node1, &node1);
  145. /*<       nodplc(loc+11)=indxx(node2,node2) >*/
  146.     nodplc[loc + 10] = indxx_(&node2, &node2);
  147. /*<       loc=nodplc(loc) >*/
  148.     loc = nodplc[loc - 1];
  149. /*<       go to 710 >*/
  150.     goto L710;
  151.  
  152. /*  inductors */
  153.  
  154. /*<   720 loc=locate(3) >*/
  155. L720:
  156.     loc = cirdat_1.locate[2];
  157. /*<   730 if ((loc.eq.0).or.(nodplc(loc+14).ne.0)) go to 740 >*/
  158. L730:
  159.     if (loc == 0 || nodplc[loc + 13] != 0) {
  160.     goto L740;
  161.     }
  162. /*<       node1=nodplc(loc+2) >*/
  163.     node1 = nodplc[loc + 1];
  164. /*<       node2=nodplc(loc+3) >*/
  165.     node2 = nodplc[loc + 2];
  166. /*<       ibr=nodplc(loc+5) >*/
  167.     cirdat_1.ibr = nodplc[loc + 4];
  168. /*<       nodplc(loc+6)=indxx(node1,ibr) >*/
  169.     nodplc[loc + 5] = indxx_(&node1, &cirdat_1.ibr);
  170. /*<       nodplc(loc+7)=indxx(node2,ibr) >*/
  171.     nodplc[loc + 6] = indxx_(&node2, &cirdat_1.ibr);
  172. /*<       nodplc(loc+8)=indxx(ibr,node1) >*/
  173.     nodplc[loc + 7] = indxx_(&cirdat_1.ibr, &node1);
  174. /*<       nodplc(loc+9)=indxx(ibr,node2) >*/
  175.     nodplc[loc + 8] = indxx_(&cirdat_1.ibr, &node2);
  176. /*<       nodplc(loc+13)=indxx(ibr,ibr) >*/
  177.     nodplc[loc + 12] = indxx_(&cirdat_1.ibr, &cirdat_1.ibr);
  178. /*<       loc=nodplc(loc) >*/
  179.     loc = nodplc[loc - 1];
  180. /*<       go to 730 >*/
  181.     goto L730;
  182.  
  183. /*  mutual inductances */
  184.  
  185. /*<   740 loc=locate(4) >*/
  186. L740:
  187.     loc = cirdat_1.locate[3];
  188. /*<   750 if ((loc.eq.0).or.(nodplc(loc+6).ne.0)) go to 760 >*/
  189. L750:
  190.     if (loc == 0 || nodplc[loc + 5] != 0) {
  191.     goto L760;
  192.     }
  193. /*<       nl1=nodplc(loc+2) >*/
  194.     nl1 = nodplc[loc + 1];
  195. /*<       nl2=nodplc(loc+3) >*/
  196.     nl2 = nodplc[loc + 2];
  197. /*<       ibr1=nodplc(nl1+5) >*/
  198.     ibr1 = nodplc[nl1 + 4];
  199. /*<       ibr2=nodplc(nl2+5) >*/
  200.     ibr2 = nodplc[nl2 + 4];
  201. /*<       nodplc(loc+4)=indxx(ibr1,ibr2) >*/
  202.     nodplc[loc + 3] = indxx_(&ibr1, &ibr2);
  203. /*<       nodplc(loc+5)=indxx(ibr2,ibr1) >*/
  204.     nodplc[loc + 4] = indxx_(&ibr2, &ibr1);
  205. /*<       loc=nodplc(loc) >*/
  206.     loc = nodplc[loc - 1];
  207. /*<       go to 750 >*/
  208.     goto L750;
  209.  
  210. /*  nonlinear voltage controlled current sources */
  211.  
  212. /*<   760 loc=locate(5) >*/
  213. L760:
  214.     loc = cirdat_1.locate[4];
  215. /*<   762 if ((loc.eq.0).or.(nodplc(loc+13).ne.0)) go to 764 >*/
  216. L762:
  217.     if (loc == 0 || nodplc[loc + 12] != 0) {
  218.     goto L764;
  219.     }
  220. /*<       node1=nodplc(loc+2) >*/
  221.     node1 = nodplc[loc + 1];
  222. /*<       node2=nodplc(loc+3) >*/
  223.     node2 = nodplc[loc + 2];
  224. /*<       ndim=nodplc(loc+4) >*/
  225.     ndim = nodplc[loc + 3];
  226. /*<       lnod=nodplc(loc+6) >*/
  227.     lnod = nodplc[loc + 5];
  228. /*<       lmat=nodplc(loc+7) >*/
  229.     lmat = nodplc[loc + 6];
  230. /*<       do 763 i=1,ndim >*/
  231.     i_1 = ndim;
  232.     for (i = 1; i <= i_1; ++i) {
  233. /*<       node3=nodplc(lnod+1) >*/
  234.     node3 = nodplc[lnod];
  235. /*<       node4=nodplc(lnod+2) >*/
  236.     node4 = nodplc[lnod + 1];
  237. /*<       lnod=lnod+2 >*/
  238.     lnod += 2;
  239. /*<       nodplc(lmat+1)=indxx(node1,node3) >*/
  240.     nodplc[lmat] = indxx_(&node1, &node3);
  241. /*<       nodplc(lmat+2)=indxx(node1,node4) >*/
  242.     nodplc[lmat + 1] = indxx_(&node1, &node4);
  243. /*<       nodplc(lmat+3)=indxx(node2,node3) >*/
  244.     nodplc[lmat + 2] = indxx_(&node2, &node3);
  245. /*<       nodplc(lmat+4)=indxx(node2,node4) >*/
  246.     nodplc[lmat + 3] = indxx_(&node2, &node4);
  247. /*<       lmat=lmat+4 >*/
  248.     lmat += 4;
  249. /*<   763 continue >*/
  250. /* L763: */
  251.     }
  252. /*<       loc=nodplc(loc) >*/
  253.     loc = nodplc[loc - 1];
  254. /*<       go to 762 >*/
  255.     goto L762;
  256.  
  257. /*  nonlinear voltage controlled voltage sources */
  258.  
  259. /*<   764 loc=locate(6) >*/
  260. L764:
  261.     loc = cirdat_1.locate[5];
  262. /*<   766 if ((loc.eq.0).or.(nodplc(loc+14).ne.0)) go to 768 >*/
  263. L766:
  264.     if (loc == 0 || nodplc[loc + 13] != 0) {
  265.     goto L768;
  266.     }
  267. /*<       node1=nodplc(loc+2) >*/
  268.     node1 = nodplc[loc + 1];
  269. /*<       node2=nodplc(loc+3) >*/
  270.     node2 = nodplc[loc + 2];
  271. /*<       ndim=nodplc(loc+4) >*/
  272.     ndim = nodplc[loc + 3];
  273. /*<       ibr=nodplc(loc+6) >*/
  274.     cirdat_1.ibr = nodplc[loc + 5];
  275. /*<       lnod=nodplc(loc+7) >*/
  276.     lnod = nodplc[loc + 6];
  277. /*<       lmat=nodplc(loc+8) >*/
  278.     lmat = nodplc[loc + 7];
  279. /*<       nodplc(lmat+1)=indxx(node1,ibr) >*/
  280.     nodplc[lmat] = indxx_(&node1, &cirdat_1.ibr);
  281. /*<       nodplc(lmat+2)=indxx(node2,ibr) >*/
  282.     nodplc[lmat + 1] = indxx_(&node2, &cirdat_1.ibr);
  283. /*<       nodplc(lmat+3)=indxx(ibr,node1) >*/
  284.     nodplc[lmat + 2] = indxx_(&cirdat_1.ibr, &node1);
  285. /*<       nodplc(lmat+4)=indxx(ibr,node2) >*/
  286.     nodplc[lmat + 3] = indxx_(&cirdat_1.ibr, &node2);
  287. /*<       lmat=lmat+4 >*/
  288.     lmat += 4;
  289. /*<       do 767 i=1,ndim >*/
  290.     i_1 = ndim;
  291.     for (i = 1; i <= i_1; ++i) {
  292. /*<       node3=nodplc(lnod+1) >*/
  293.     node3 = nodplc[lnod];
  294. /*<       node4=nodplc(lnod+2) >*/
  295.     node4 = nodplc[lnod + 1];
  296. /*<       lnod=lnod+2 >*/
  297.     lnod += 2;
  298. /*<       nodplc(lmat+1)=indxx(ibr,node3) >*/
  299.     nodplc[lmat] = indxx_(&cirdat_1.ibr, &node3);
  300. /*<       nodplc(lmat+2)=indxx(ibr,node4) >*/
  301.     nodplc[lmat + 1] = indxx_(&cirdat_1.ibr, &node4);
  302. /*<       lmat=lmat+2 >*/
  303.     lmat += 2;
  304. /*<   767 continue >*/
  305. /* L767: */
  306.     }
  307. /*<       loc=nodplc(loc) >*/
  308.     loc = nodplc[loc - 1];
  309. /*<       go to 766 >*/
  310.     goto L766;
  311.  
  312. /*  nonlinear current controlled current sources */
  313.  
  314. /*<   768 loc=locate(7) >*/
  315. L768:
  316.     loc = cirdat_1.locate[6];
  317. /*<   770 if ((loc.eq.0).or.(nodplc(loc+13).ne.0)) go to 772 >*/
  318. L770:
  319.     if (loc == 0 || nodplc[loc + 12] != 0) {
  320.     goto L772;
  321.     }
  322. /*<       node1=nodplc(loc+2) >*/
  323.     node1 = nodplc[loc + 1];
  324. /*<       node2=nodplc(loc+3) >*/
  325.     node2 = nodplc[loc + 2];
  326. /*<       ndim=nodplc(loc+4) >*/
  327.     ndim = nodplc[loc + 3];
  328. /*<       locvs=nodplc(loc+6) >*/
  329.     locvs = nodplc[loc + 5];
  330. /*<       lmat=nodplc(loc+7) >*/
  331.     lmat = nodplc[loc + 6];
  332. /*<       do 771 i=1,ndim >*/
  333.     i_1 = ndim;
  334.     for (i = 1; i <= i_1; ++i) {
  335. /*<       locvst=nodplc(locvs+i) >*/
  336.     locvst = nodplc[locvs + i - 1];
  337. /*<       ibr=nodplc(locvst+6) >*/
  338.     cirdat_1.ibr = nodplc[locvst + 5];
  339. /*<       nodplc(lmat+1)=indxx(node1,ibr) >*/
  340.     nodplc[lmat] = indxx_(&node1, &cirdat_1.ibr);
  341. /*<       nodplc(lmat+2)=indxx(node2,ibr) >*/
  342.     nodplc[lmat + 1] = indxx_(&node2, &cirdat_1.ibr);
  343. /*<       lmat=lmat+2 >*/
  344.     lmat += 2;
  345. /*<   771 continue >*/
  346. /* L771: */
  347.     }
  348. /*<       loc=nodplc(loc) >*/
  349.     loc = nodplc[loc - 1];
  350. /*<       go to 770 >*/
  351.     goto L770;
  352.  
  353. /*  nonlinear current controlled voltage sources */
  354.  
  355. /*<   772 loc=locate(8) >*/
  356. L772:
  357.     loc = cirdat_1.locate[7];
  358. /*<   774 if ((loc.eq.0).or.(nodplc(loc+14).ne.0)) go to 780 >*/
  359. L774:
  360.     if (loc == 0 || nodplc[loc + 13] != 0) {
  361.     goto L780;
  362.     }
  363. /*<       node1=nodplc(loc+2) >*/
  364.     node1 = nodplc[loc + 1];
  365. /*<       node2=nodplc(loc+3) >*/
  366.     node2 = nodplc[loc + 2];
  367. /*<       ndim=nodplc(loc+4) >*/
  368.     ndim = nodplc[loc + 3];
  369. /*<       ibr=nodplc(loc+6) >*/
  370.     cirdat_1.ibr = nodplc[loc + 5];
  371. /*<       locvs=nodplc(loc+7) >*/
  372.     locvs = nodplc[loc + 6];
  373. /*<       lmat=nodplc(loc+8) >*/
  374.     lmat = nodplc[loc + 7];
  375. /*<       nodplc(lmat+1)=indxx(node1,ibr) >*/
  376.     nodplc[lmat] = indxx_(&node1, &cirdat_1.ibr);
  377. /*<       nodplc(lmat+2)=indxx(node2,ibr) >*/
  378.     nodplc[lmat + 1] = indxx_(&node2, &cirdat_1.ibr);
  379. /*<       nodplc(lmat+3)=indxx(ibr,node1) >*/
  380.     nodplc[lmat + 2] = indxx_(&cirdat_1.ibr, &node1);
  381. /*<       nodplc(lmat+4)=indxx(ibr,node2) >*/
  382.     nodplc[lmat + 3] = indxx_(&cirdat_1.ibr, &node2);
  383. /*<       lmat=lmat+4 >*/
  384.     lmat += 4;
  385. /*<       do 775 i=1,ndim >*/
  386.     i_1 = ndim;
  387.     for (i = 1; i <= i_1; ++i) {
  388. /*<       locvst=nodplc(locvs+i) >*/
  389.     locvst = nodplc[locvs + i - 1];
  390. /*<       kbr=nodplc(locvst+6) >*/
  391.     kbr = nodplc[locvst + 5];
  392. /*<       nodplc(lmat+i)=indxx(ibr,kbr) >*/
  393.     nodplc[lmat + i - 1] = indxx_(&cirdat_1.ibr, &kbr);
  394. /*<   775 continue >*/
  395. /* L775: */
  396.     }
  397. /*<       loc=nodplc(loc) >*/
  398.     loc = nodplc[loc - 1];
  399. /*<       go to 774 >*/
  400.     goto L774;
  401.  
  402. /*  voltage sources */
  403.  
  404. /*<   780 loc=locate(9) >*/
  405. L780:
  406.     loc = cirdat_1.locate[8];
  407. /*<   790 if ((loc.eq.0).or.(nodplc(loc+11).ne.0)) go to 800 >*/
  408. L790:
  409.     if (loc == 0 || nodplc[loc + 10] != 0) {
  410.     goto L800;
  411.     }
  412. /*<       node1=nodplc(loc+2) >*/
  413.     node1 = nodplc[loc + 1];
  414. /*<       node2=nodplc(loc+3) >*/
  415.     node2 = nodplc[loc + 2];
  416. /*<       iptr=nodplc(loc+6) >*/
  417.     iptr = nodplc[loc + 5];
  418. /*<       nodplc(loc+7)=indxx(node1,iptr) >*/
  419.     nodplc[loc + 6] = indxx_(&node1, &iptr);
  420. /*<       nodplc(loc+8)=indxx(node2,iptr) >*/
  421.     nodplc[loc + 7] = indxx_(&node2, &iptr);
  422. /*<       nodplc(loc+9)=indxx(iptr,node1) >*/
  423.     nodplc[loc + 8] = indxx_(&iptr, &node1);
  424. /*<       nodplc(loc+10)=indxx(iptr,node2) >*/
  425.     nodplc[loc + 9] = indxx_(&iptr, &node2);
  426. /*<       loc=nodplc(loc) >*/
  427.     loc = nodplc[loc - 1];
  428. /*<       go to 790 >*/
  429.     goto L790;
  430.  
  431. /*  diodes */
  432.  
  433. /*<   800 loc=locate(11) >*/
  434. L800:
  435.     loc = cirdat_1.locate[10];
  436. /*<   810 if ((loc.eq.0).or.(nodplc(loc+16).ne.0)) go to 820 >*/
  437. L810:
  438.     if (loc == 0 || nodplc[loc + 15] != 0) {
  439.     goto L820;
  440.     }
  441. /*<       node1=nodplc(loc+2) >*/
  442.     node1 = nodplc[loc + 1];
  443. /*<       node2=nodplc(loc+3) >*/
  444.     node2 = nodplc[loc + 2];
  445. /*<       node3=nodplc(loc+4) >*/
  446.     node3 = nodplc[loc + 3];
  447. /*<       nodplc(loc+7)=indxx(node1,node3) >*/
  448.     nodplc[loc + 6] = indxx_(&node1, &node3);
  449. /*<       nodplc(loc+8)=indxx(node2,node3) >*/
  450.     nodplc[loc + 7] = indxx_(&node2, &node3);
  451. /*<       nodplc(loc+9)=indxx(node3,node1) >*/
  452.     nodplc[loc + 8] = indxx_(&node3, &node1);
  453. /*<       nodplc(loc+10)=indxx(node3,node2) >*/
  454.     nodplc[loc + 9] = indxx_(&node3, &node2);
  455. /*<       nodplc(loc+13)=indxx(node1,node1) >*/
  456.     nodplc[loc + 12] = indxx_(&node1, &node1);
  457. /*<       nodplc(loc+14)=indxx(node2,node2) >*/
  458.     nodplc[loc + 13] = indxx_(&node2, &node2);
  459. /*<       nodplc(loc+15)=indxx(node3,node3) >*/
  460.     nodplc[loc + 14] = indxx_(&node3, &node3);
  461. /*<       loc=nodplc(loc) >*/
  462.     loc = nodplc[loc - 1];
  463. /*<       go to 810 >*/
  464.     goto L810;
  465.  
  466. /*  transistors */
  467.  
  468. /*<   820 loc=locate(12) >*/
  469. L820:
  470.     loc = cirdat_1.locate[11];
  471. /*<   830 if ((loc.eq.0).or.(nodplc(loc+36).ne.0)) go to 840 >*/
  472. L830:
  473.     if (loc == 0 || nodplc[loc + 35] != 0) {
  474.     goto L840;
  475.     }
  476. /*<       node1=nodplc(loc+2) >*/
  477.     node1 = nodplc[loc + 1];
  478. /*<       node2=nodplc(loc+3) >*/
  479.     node2 = nodplc[loc + 2];
  480. /*<       node3=nodplc(loc+4) >*/
  481.     node3 = nodplc[loc + 3];
  482. /*<       node4=nodplc(loc+5) >*/
  483.     node4 = nodplc[loc + 4];
  484. /*<       node5=nodplc(loc+6) >*/
  485.     node5 = nodplc[loc + 5];
  486. /*<       node6=nodplc(loc+7) >*/
  487.     node6 = nodplc[loc + 6];
  488. /*<       node7=nodplc(loc+30) >*/
  489.     node7 = nodplc[loc + 29];
  490. /*<       nodplc(loc+10)=indxx(node1,node4) >*/
  491.     nodplc[loc + 9] = indxx_(&node1, &node4);
  492. /*<       nodplc(loc+11)=indxx(node2,node5) >*/
  493.     nodplc[loc + 10] = indxx_(&node2, &node5);
  494. /*<       nodplc(loc+12)=indxx(node3,node6) >*/
  495.     nodplc[loc + 11] = indxx_(&node3, &node6);
  496. /*<       nodplc(loc+13)=indxx(node4,node1) >*/
  497.     nodplc[loc + 12] = indxx_(&node4, &node1);
  498. /*<       nodplc(loc+14)=indxx(node4,node5) >*/
  499.     nodplc[loc + 13] = indxx_(&node4, &node5);
  500. /*<       nodplc(loc+15)=indxx(node4,node6) >*/
  501.     nodplc[loc + 14] = indxx_(&node4, &node6);
  502. /*<       nodplc(loc+16)=indxx(node5,node2) >*/
  503.     nodplc[loc + 15] = indxx_(&node5, &node2);
  504. /*<       nodplc(loc+17)=indxx(node5,node4) >*/
  505.     nodplc[loc + 16] = indxx_(&node5, &node4);
  506. /*<       nodplc(loc+18)=indxx(node5,node6) >*/
  507.     nodplc[loc + 17] = indxx_(&node5, &node6);
  508. /*<       nodplc(loc+19)=indxx(node6,node3) >*/
  509.     nodplc[loc + 18] = indxx_(&node6, &node3);
  510. /*<       nodplc(loc+20)=indxx(node6,node4) >*/
  511.     nodplc[loc + 19] = indxx_(&node6, &node4);
  512. /*<       nodplc(loc+21)=indxx(node6,node5) >*/
  513.     nodplc[loc + 20] = indxx_(&node6, &node5);
  514. /*<       nodplc(loc+24)=indxx(node1,node1) >*/
  515.     nodplc[loc + 23] = indxx_(&node1, &node1);
  516. /*<       nodplc(loc+25)=indxx(node2,node2) >*/
  517.     nodplc[loc + 24] = indxx_(&node2, &node2);
  518. /*<       nodplc(loc+26)=indxx(node3,node3) >*/
  519.     nodplc[loc + 25] = indxx_(&node3, &node3);
  520. /*<       nodplc(loc+27)=indxx(node4,node4) >*/
  521.     nodplc[loc + 26] = indxx_(&node4, &node4);
  522. /*<       nodplc(loc+28)=indxx(node5,node5) >*/
  523.     nodplc[loc + 27] = indxx_(&node5, &node5);
  524. /*<       nodplc(loc+29)=indxx(node6,node6) >*/
  525.     nodplc[loc + 28] = indxx_(&node6, &node6);
  526. /*<       nodplc(loc+31)=indxx(node7,node7) >*/
  527.     nodplc[loc + 30] = indxx_(&node7, &node7);
  528. /*<       nodplc(loc+32)=indxx(node4,node7) >*/
  529.     nodplc[loc + 31] = indxx_(&node4, &node7);
  530. /*<       nodplc(loc+33)=indxx(node7,node4) >*/
  531.     nodplc[loc + 32] = indxx_(&node7, &node4);
  532. /*<       nodplc(loc+34)=indxx(node2,node4) >*/
  533.     nodplc[loc + 33] = indxx_(&node2, &node4);
  534. /*<       nodplc(loc+35)=indxx(node4,node2) >*/
  535.     nodplc[loc + 34] = indxx_(&node4, &node2);
  536. /*<       loc=nodplc(loc) >*/
  537.     loc = nodplc[loc - 1];
  538. /*<       go to 830 >*/
  539.     goto L830;
  540.  
  541. /*  jfets */
  542.  
  543. /*<   840 loc=locate(13) >*/
  544. L840:
  545.     loc = cirdat_1.locate[12];
  546. /*<   850 if ((loc.eq.0).or.(nodplc(loc+25).ne.0)) go to 860 >*/
  547. L850:
  548.     if (loc == 0 || nodplc[loc + 24] != 0) {
  549.     goto L860;
  550.     }
  551. /*<       node1=nodplc(loc+2) >*/
  552.     node1 = nodplc[loc + 1];
  553. /*<       node2=nodplc(loc+3) >*/
  554.     node2 = nodplc[loc + 2];
  555. /*<       node3=nodplc(loc+4) >*/
  556.     node3 = nodplc[loc + 3];
  557. /*<       node4=nodplc(loc+5) >*/
  558.     node4 = nodplc[loc + 4];
  559. /*<       node5=nodplc(loc+6) >*/
  560.     node5 = nodplc[loc + 5];
  561. /*<       nodplc(loc+9)=indxx(node1,node4) >*/
  562.     nodplc[loc + 8] = indxx_(&node1, &node4);
  563. /*<       nodplc(loc+10)=indxx(node2,node4) >*/
  564.     nodplc[loc + 9] = indxx_(&node2, &node4);
  565. /*<       nodplc(loc+11)=indxx(node2,node5) >*/
  566.     nodplc[loc + 10] = indxx_(&node2, &node5);
  567. /*<       nodplc(loc+12)=indxx(node3,node5) >*/
  568.     nodplc[loc + 11] = indxx_(&node3, &node5);
  569. /*<       nodplc(loc+13)=indxx(node4,node1) >*/
  570.     nodplc[loc + 12] = indxx_(&node4, &node1);
  571. /*<       nodplc(loc+14)=indxx(node4,node2) >*/
  572.     nodplc[loc + 13] = indxx_(&node4, &node2);
  573. /*<       nodplc(loc+15)=indxx(node4,node5) >*/
  574.     nodplc[loc + 14] = indxx_(&node4, &node5);
  575. /*<       nodplc(loc+16)=indxx(node5,node2) >*/
  576.     nodplc[loc + 15] = indxx_(&node5, &node2);
  577. /*<       nodplc(loc+17)=indxx(node5,node3) >*/
  578.     nodplc[loc + 16] = indxx_(&node5, &node3);
  579. /*<       nodplc(loc+18)=indxx(node5,node4) >*/
  580.     nodplc[loc + 17] = indxx_(&node5, &node4);
  581. /*<       nodplc(loc+20)=indxx(node1,node1) >*/
  582.     nodplc[loc + 19] = indxx_(&node1, &node1);
  583. /*<       nodplc(loc+21)=indxx(node2,node2) >*/
  584.     nodplc[loc + 20] = indxx_(&node2, &node2);
  585. /*<       nodplc(loc+22)=indxx(node3,node3) >*/
  586.     nodplc[loc + 21] = indxx_(&node3, &node3);
  587. /*<       nodplc(loc+23)=indxx(node4,node4) >*/
  588.     nodplc[loc + 22] = indxx_(&node4, &node4);
  589. /*<       nodplc(loc+24)=indxx(node5,node5) >*/
  590.     nodplc[loc + 23] = indxx_(&node5, &node5);
  591. /*<       loc=nodplc(loc) >*/
  592.     loc = nodplc[loc - 1];
  593. /*<       go to 850 >*/
  594.     goto L850;
  595.  
  596. /*  mosfets */
  597.  
  598. /*<   860 loc=locate(14) >*/
  599. L860:
  600.     loc = cirdat_1.locate[13];
  601. /*<   870 if ((loc.eq.0).or.(nodplc(loc+33).ne.0)) go to 900 >*/
  602. L870:
  603.     if (loc == 0 || nodplc[loc + 32] != 0) {
  604.     goto L900;
  605.     }
  606. /*<       node1=nodplc(loc+2) >*/
  607.     node1 = nodplc[loc + 1];
  608. /*<       node2=nodplc(loc+3) >*/
  609.     node2 = nodplc[loc + 2];
  610. /*<       node3=nodplc(loc+4) >*/
  611.     node3 = nodplc[loc + 3];
  612. /*<       node4=nodplc(loc+5) >*/
  613.     node4 = nodplc[loc + 4];
  614. /*<       node5=nodplc(loc+6) >*/
  615.     node5 = nodplc[loc + 5];
  616. /*<       node6=nodplc(loc+7) >*/
  617.     node6 = nodplc[loc + 6];
  618. /*<       nodplc(loc+10)=indxx(node1,node5) >*/
  619.     nodplc[loc + 9] = indxx_(&node1, &node5);
  620. /*<       nodplc(loc+11)=indxx(node2,node4) >*/
  621.     nodplc[loc + 10] = indxx_(&node2, &node4);
  622. /*<       nodplc(loc+12)=indxx(node2,node5) >*/
  623.     nodplc[loc + 11] = indxx_(&node2, &node5);
  624. /*<       nodplc(loc+13)=indxx(node2,node6) >*/
  625.     nodplc[loc + 12] = indxx_(&node2, &node6);
  626. /*<       nodplc(loc+14)=indxx(node3,node6) >*/
  627.     nodplc[loc + 13] = indxx_(&node3, &node6);
  628. /*<       nodplc(loc+15)=indxx(node4,node2) >*/
  629.     nodplc[loc + 14] = indxx_(&node4, &node2);
  630. /*<       nodplc(loc+16)=indxx(node4,node5) >*/
  631.     nodplc[loc + 15] = indxx_(&node4, &node5);
  632. /*<       nodplc(loc+17)=indxx(node4,node6) >*/
  633.     nodplc[loc + 16] = indxx_(&node4, &node6);
  634. /*<       nodplc(loc+18)=indxx(node5,node1) >*/
  635.     nodplc[loc + 17] = indxx_(&node5, &node1);
  636. /*<       nodplc(loc+19)=indxx(node5,node2) >*/
  637.     nodplc[loc + 18] = indxx_(&node5, &node2);
  638. /*<       nodplc(loc+20)=indxx(node5,node4) >*/
  639.     nodplc[loc + 19] = indxx_(&node5, &node4);
  640. /*<       nodplc(loc+21)=indxx(node5,node6) >*/
  641.     nodplc[loc + 20] = indxx_(&node5, &node6);
  642. /*<       nodplc(loc+22)=indxx(node6,node2) >*/
  643.     nodplc[loc + 21] = indxx_(&node6, &node2);
  644. /*<       nodplc(loc+23)=indxx(node6,node3) >*/
  645.     nodplc[loc + 22] = indxx_(&node6, &node3);
  646. /*<       nodplc(loc+24)=indxx(node6,node4) >*/
  647.     nodplc[loc + 23] = indxx_(&node6, &node4);
  648. /*<       nodplc(loc+25)=indxx(node6,node5) >*/
  649.     nodplc[loc + 24] = indxx_(&node6, &node5);
  650. /*<       nodplc(loc+27)=indxx(node1,node1) >*/
  651.     nodplc[loc + 26] = indxx_(&node1, &node1);
  652. /*<       nodplc(loc+28)=indxx(node2,node2) >*/
  653.     nodplc[loc + 27] = indxx_(&node2, &node2);
  654. /*<       nodplc(loc+29)=indxx(node3,node3) >*/
  655.     nodplc[loc + 28] = indxx_(&node3, &node3);
  656. /*<       nodplc(loc+30)=indxx(node4,node4) >*/
  657.     nodplc[loc + 29] = indxx_(&node4, &node4);
  658. /*<       nodplc(loc+31)=indxx(node5,node5) >*/
  659.     nodplc[loc + 30] = indxx_(&node5, &node5);
  660. /*<       nodplc(loc+32)=indxx(node6,node6) >*/
  661.     nodplc[loc + 31] = indxx_(&node6, &node6);
  662. /*<       loc=nodplc(loc) >*/
  663.     loc = nodplc[loc - 1];
  664. /*<       go to 870 >*/
  665.     goto L870;
  666.  
  667. /*  transmission lines */
  668.  
  669. /*<   900 loc=locate(17) >*/
  670. L900:
  671.     loc = cirdat_1.locate[16];
  672. /*<   910 if ((loc.eq.0).or.(nodplc(loc+33).ne.0)) go to 1000 >*/
  673. L910:
  674.     if (loc == 0 || nodplc[loc + 32] != 0) {
  675.     goto L1000;
  676.     }
  677. /*<       node1=nodplc(loc+2) >*/
  678.     node1 = nodplc[loc + 1];
  679. /*<       node2=nodplc(loc+3) >*/
  680.     node2 = nodplc[loc + 2];
  681. /*<       node3=nodplc(loc+4) >*/
  682.     node3 = nodplc[loc + 3];
  683. /*<       node4=nodplc(loc+5) >*/
  684.     node4 = nodplc[loc + 4];
  685. /*<       ni1=nodplc(loc+6) >*/
  686.     ni1 = nodplc[loc + 5];
  687. /*<       ni2=nodplc(loc+7) >*/
  688.     ni2 = nodplc[loc + 6];
  689. /*<       ibr1=nodplc(loc+8) >*/
  690.     ibr1 = nodplc[loc + 7];
  691. /*<       ibr2=nodplc(loc+9) >*/
  692.     ibr2 = nodplc[loc + 8];
  693. /*<       nodplc(loc+10)=indxx(node1,node1) >*/
  694.     nodplc[loc + 9] = indxx_(&node1, &node1);
  695. /*<       nodplc(loc+11)=indxx(node1,ni1) >*/
  696.     nodplc[loc + 10] = indxx_(&node1, &ni1);
  697. /*<       nodplc(loc+12)=indxx(node2,ibr1) >*/
  698.     nodplc[loc + 11] = indxx_(&node2, &ibr1);
  699. /*<       nodplc(loc+13)=indxx(node3,node3) >*/
  700.     nodplc[loc + 12] = indxx_(&node3, &node3);
  701. /*<       nodplc(loc+14)=indxx(node4,ibr2) >*/
  702.     nodplc[loc + 13] = indxx_(&node4, &ibr2);
  703. /*<       nodplc(loc+15)=indxx(ni1,node1) >*/
  704.     nodplc[loc + 14] = indxx_(&ni1, &node1);
  705. /*<       nodplc(loc+16)=indxx(ni1,ni1) >*/
  706.     nodplc[loc + 15] = indxx_(&ni1, &ni1);
  707. /*<       nodplc(loc+17)=indxx(ni1,ibr1) >*/
  708.     nodplc[loc + 16] = indxx_(&ni1, &ibr1);
  709. /*<       nodplc(loc+18)=indxx(ni2,ni2) >*/
  710.     nodplc[loc + 17] = indxx_(&ni2, &ni2);
  711. /*<       nodplc(loc+19)=indxx(ni2,ibr2) >*/
  712.     nodplc[loc + 18] = indxx_(&ni2, &ibr2);
  713. /*<       nodplc(loc+20)=indxx(ibr1,node2) >*/
  714.     nodplc[loc + 19] = indxx_(&ibr1, &node2);
  715. /*<       nodplc(loc+21)=indxx(ibr1,node3) >*/
  716.     nodplc[loc + 20] = indxx_(&ibr1, &node3);
  717. /*<       nodplc(loc+22)=indxx(ibr1,node4) >*/
  718.     nodplc[loc + 21] = indxx_(&ibr1, &node4);
  719. /*<       nodplc(loc+23)=indxx(ibr1,ni1) >*/
  720.     nodplc[loc + 22] = indxx_(&ibr1, &ni1);
  721. /*<       nodplc(loc+24)=indxx(ibr1,ibr2) >*/
  722.     nodplc[loc + 23] = indxx_(&ibr1, &ibr2);
  723. /*<       nodplc(loc+25)=indxx(ibr2,node1) >*/
  724.     nodplc[loc + 24] = indxx_(&ibr2, &node1);
  725. /*<       nodplc(loc+26)=indxx(ibr2,node2) >*/
  726.     nodplc[loc + 25] = indxx_(&ibr2, &node2);
  727. /*<       nodplc(loc+27)=indxx(ibr2,node4) >*/
  728.     nodplc[loc + 26] = indxx_(&ibr2, &node4);
  729. /*<       nodplc(loc+28)=indxx(ibr2,ni2) >*/
  730.     nodplc[loc + 27] = indxx_(&ibr2, &ni2);
  731. /*<       nodplc(loc+29)=indxx(ibr2,ibr1) >*/
  732.     nodplc[loc + 28] = indxx_(&ibr2, &ibr1);
  733. /*<       nodplc(loc+31)=indxx(node3,ni2) >*/
  734.     nodplc[loc + 30] = indxx_(&node3, &ni2);
  735. /*<       nodplc(loc+32)=indxx(ni2,node3) >*/
  736.     nodplc[loc + 31] = indxx_(&ni2, &node3);
  737. /*<       loc=nodplc(loc) >*/
  738.     loc = nodplc[loc - 1];
  739. /*<       go to 910 >*/
  740.     goto L910;
  741.  
  742. /*  finished */
  743.  
  744. /*<  1000 return >*/
  745. L1000:
  746.     return 0;
  747. /*<       end >*/
  748. } /* matloc_ */
  749.  
  750. #undef cvalue
  751. #undef nodplc
  752.  
  753.  
  754.